﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Excel = Microsoft.Office.Interop.Excel;
using PlanProd.Contracts;
using System.Data.OleDb;
using System.Data;
using System.Collections.Specialized;
using System.Configuration;
using Web.Framework.Helpers;

namespace WebAppPlanProduccion.Code
{
    public class ExcelHelper
    {
        /// <summary>
        /// Recibe el pedido comercial detalle
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static List<PedidoComercialDetalle> GetPedidoComercialDetalleFromExcel(string filePath, PedidoComercial pedidoComercial, List<string> parseErrors)
        {
            List<PedidoComercialDetalle> pedidoComercialDetalleList = new List<PedidoComercialDetalle>();

            DataTable dataTable = GetDataTableFromExcel(filePath);
            int temporadaIndex = 0;
            int destinoIndex = 1;
            int productoIndex = 2;
            int colorIndex = 3;
            int cantidadIndex = 4;
            const int cantidadColumnas = 5;
            if (dataTable.Columns.Count != cantidadColumnas)
            {
                throw new Exception(string.Format("El excel debe contener {0} columnas", cantidadColumnas));
            }

            string value = string.Empty;
            for (int i = 0; i < cantidadColumnas; i++)
            {
                value = dataTable.Columns[i].ColumnName;
                if (value.ToLower() == "temporada")
                {
                    temporadaIndex = i;
                }
                else if (value.ToLower() == "destino")
                {
                    destinoIndex = i;
                }
                else if (value.ToLower() == "producto")
                {
                    productoIndex = i;
                }
                else if (value.ToLower() == "color")
                {
                    colorIndex = i;
                }
                else if (value.ToLower() == "cantidad")
                {
                    cantidadIndex = i;
                }
            }

            string temporada;
            string destino;
            string producto;
            string color;
            int cantidad;
            for (int i = 0; i < dataTable.Rows.Count; i++)
            {
                if (dataTable.Rows[i][temporadaIndex] != DBNull.Value)
                {
                    PedidoComercialDetalle pedidoComercialDetalle = new PedidoComercialDetalle();

                    temporada = dataTable.Rows[i][temporadaIndex].ToString();
                    destino = dataTable.Rows[i][destinoIndex].ToString();
                    producto = dataTable.Rows[i][productoIndex].ToString();
                    color = dataTable.Rows[i][colorIndex].ToString();

                    bool errorEnTemporada = true;
                    if (!String.IsNullOrEmpty(temporada))
                    {
                        if (temporada.ToLower() == pedidoComercial.TemporadaCodigoExterno.ToLower())
                        {
                            errorEnTemporada = false;
                        }
                    }

                    if (errorEnTemporada)
                    {
                        parseErrors.Add(string.Format("Fila {0}, columna {1}: La temporada {2} no coincide con el pedido comercial {3}, temporada {4}", i + 1, temporadaIndex, temporada, pedidoComercial.Id, pedidoComercial.TemporadaId));
                    }

                    bool errorEnDestino = true;
                    if (!String.IsNullOrEmpty(destino))
                    {
                        if (destino.ToLower() == pedidoComercial.DestinoCodigoExterno.ToLower())
                        {
                            errorEnDestino = false;
                        }
                    }

                    if (errorEnDestino)
                    {
                        parseErrors.Add(string.Format("Fila {0}, columna {1}: El destino {2} no coincide con el pedido comercial {3}, destino {4}", i + 1, destinoIndex, destino, pedidoComercial.Id, pedidoComercial.DestinoId));
                    }

                    if (!String.IsNullOrEmpty(producto) && producto.Length == 8)
                    {
                        pedidoComercialDetalle.ProductoIdExterno = producto;
                    }
                    else
                    {
                        parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar. Controle que sea un valor de 8 letras", i, productoIndex, producto));
                    }

                    if (!String.IsNullOrEmpty(color) && color.Length == 3)
                    {
                        pedidoComercialDetalle.ColorId = color;
                    }
                    else
                    {
                        parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar. Controle que sea un valor de 3 letras", i, colorIndex, color));
                    }

                    if (Int32.TryParse(dataTable.Rows[i][cantidadIndex].ToString(), out cantidad))
                    {
                        pedidoComercialDetalle.Cantidad = cantidad;
                    }
                    else
                    {
                        parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar. Controle que sea un número entero", i, cantidadIndex, cantidad));
                    }

                    pedidoComercialDetalleList.Add(pedidoComercialDetalle);

                }
            }

            return pedidoComercialDetalleList;
        }

        /// <summary>
        /// Recibe el pedido comercial detalle
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static List<PresupuestoProduccionDetalleProd> GetPresupuestoProduccionDetalleProdFromExcel(string filePath, PresupuestoProduccion presupuestoProduccion, Temporada temporadaObj, List<string> parseErrors)
        {
            List<PresupuestoProduccionDetalleProd> presupuestoProduccionDetalleProdList = new List<PresupuestoProduccionDetalleProd>();

            DataTable dataTable = GetDataTableFromExcel(filePath);
            int temporadaIndex = 0;
            int destinoIndex = 1;
            int proveedorIndex = 2;
            int productoIndex = 3;
            int colorIndex = 4;
            int calidadIndex = 5;
            int totalIndex = 0;

            const int cantidadColumnas = 6;

            if (dataTable.Columns.Count <= cantidadColumnas)
            {
                throw new Exception(string.Format("El excel debe contener mas de {0} columnas", cantidadColumnas));
            }

            string value = string.Empty;
            for (int i = 0; i < cantidadColumnas; i++)
            {
                value = dataTable.Columns[i].ColumnName;
                if (value.ToLower() == "temporada")
                {
                    temporadaIndex = i;
                }
                else if (value.ToLower() == "destino")
                {
                    destinoIndex = i;
                }
                else if (value.ToLower() == "proveedor")
                {
                    proveedorIndex = i;
                }
                else if (value.ToLower() == "producto")
                {
                    productoIndex = i;
                }
                else if (value.ToLower() == "color")
                {
                    colorIndex = i;
                }
                else if (value.ToLower() == "calidad")
                {
                    calidadIndex = i;
                }
            }

            HybridDictionary indiceDeSemanas = new HybridDictionary();
            for (int i = dataTable.Columns.Count - 1; i >= 0; i--)
            {
                value = dataTable.Columns[i].ColumnName;
                if (value.ToLower() == "total")
                {
                    totalIndex = i;
                }
                else if (value.ToLower().StartsWith("se"))
                {
                    string numeroStr = value.Split('-')[1];
                    int numeroSemana;
                    if (int.TryParse(numeroStr, out numeroSemana))
                    {
                        indiceDeSemanas.Add(i, numeroSemana);
                    }
                    else
                    {
                        parseErrors.Add(string.Format("No se pudo parsear la el número de semana de la cabecera en la columna {0} valor {1}", i, numeroStr));
                        throw new Exception(string.Format("No se pudo parsear la el número de semana de la cabecera en la columna {0} valor {1}", i, numeroStr));
                    }
                }
            }

            if (indiceDeSemanas.Count != 0)
            {
                if (temporadaObj != null && temporadaObj.NumeroSemanas != indiceDeSemanas.Count)
                {
                    parseErrors.Add(string.Format("La temporada {0}({1}) tiene {2} semanas y en el archivo hay {3} semanas. La cantidad de semanas debe coincidir.", temporadaObj.Nombre, temporadaObj.Id, temporadaObj.NumeroSemanas, indiceDeSemanas.Count));
                    throw new Exception(string.Format("La temporada {0}({1}) tiene {2} semanas y en el archivo hay {3} semanas. La cantidad de semanas debe coincidir.", temporadaObj.Nombre, temporadaObj.Id, temporadaObj.NumeroSemanas, indiceDeSemanas.Count));
                }
            }

            // TODO: validar columnas por semana  
            string temporada;
            string destino;
            string proveedor;
            string productoId;
            string colorId;
            int calidadId;

            for (int i = 0; i < dataTable.Rows.Count; i++)
            {
                if (dataTable.Rows[i][temporadaIndex] != DBNull.Value)
                {
                    temporada = dataTable.Rows[i][temporadaIndex].ToString();
                    bool errorEnTemporada = true;
                    if (!String.IsNullOrEmpty(temporada))
                    {
                        if (temporada.ToLower() == presupuestoProduccion.TemporadaCodigoExterno.ToLower())
                        {
                            errorEnTemporada = false;
                        }
                    }

                    if (errorEnTemporada)
                    {
                        parseErrors.Add(string.Format("Fila {0}, columna {1}: La temporada {2} no coincide con el presupuesto de producción {3}, temporada {4}", i + 1, temporadaIndex, temporada, presupuestoProduccion.Id, presupuestoProduccion.TemporadaId));
                    }

                    destino = dataTable.Rows[i][destinoIndex].ToString();
                    bool errorEnDestino = true;
                    if (!String.IsNullOrEmpty(destino))
                    {
                        if (destino.ToLower() == presupuestoProduccion.DestinoCodigoExterno.ToLower())
                        {
                            errorEnDestino = false;
                        }
                    }

                    if (errorEnDestino)
                    {
                        parseErrors.Add(string.Format("Fila {0}, columna {1}: El destino {2} no coincide con el presupuesto de producción {3}, destino {4}", i + 1, destinoIndex, destino, presupuestoProduccion.Id, presupuestoProduccion.DestinoId));
                    }

                    proveedor = dataTable.Rows[i][proveedorIndex].ToString();
                    bool errorenProveedor = true;
                    if (!String.IsNullOrEmpty(proveedor))
                    {
                        int proveedorInt;
                        if (Int32.TryParse(proveedor, out proveedorInt))
                        {
                            if (proveedorInt == presupuestoProduccion.ProveedorIdExterno)
                            {
                                errorenProveedor = false;
                            }
                        }
                    }

                    if (errorenProveedor)
                    {
                        parseErrors.Add(string.Format("Fila {0}, columna {1}: El proveedor {2} no coincide con el presupuesto de producción {3}, proveedor {4}", i + 1, proveedorIndex, proveedor, presupuestoProduccion.Id, presupuestoProduccion.ProveedorIdExterno));
                    }

                    PresupuestoProduccionDetalleProd presupuestoProduccionDetalleProd = new PresupuestoProduccionDetalleProd();
                    productoId = dataTable.Rows[i][productoIndex].ToString();
                    if (!String.IsNullOrEmpty(productoId))
                    {
                        presupuestoProduccionDetalleProd.ProductoIdExterno = productoId;
                    }
                    else
                    {
                        parseErrors.Add(string.Format("Fila: {0}, columna: {1}, el valor del producto '{2}' no se pudo parsear", i, productoIndex, productoId));
                    }

                    colorId = dataTable.Rows[i][colorIndex].ToString();
                    if (!String.IsNullOrEmpty(colorId))
                    {
                        presupuestoProduccionDetalleProd.ColorId = colorId;
                    }
                    else
                    {
                        parseErrors.Add(string.Format("Fila: {0}, columna: {1}, el valor del color '{2}' no se pudo parsear", i, colorIndex, colorId));
                    }

                    if (Int32.TryParse(dataTable.Rows[i][calidadIndex].ToString(), out calidadId))
                    {
                        presupuestoProduccionDetalleProd.CalidadId = calidadId;
                    }
                    else
                    {
                        parseErrors.Add(string.Format("Fila: {0}, columna: {1}, el valor de calidad '{2}' no se pudo parsear", i, calidadIndex, calidadId));
                    }

                    int numeroSemana = 0;
                    bool jEsI = indiceDeSemanas.Count == 0;
                    List<PresupuestoProduccionDetalleProdSemanal> cantidadesPorSemana = new List<PresupuestoProduccionDetalleProdSemanal>();
                    for (int j = cantidadColumnas; j < dataTable.Columns.Count; j++)
                    {
                        int indiceNumeroSemana = 0;
                        if (jEsI)
                        {
                            indiceNumeroSemana = j - cantidadColumnas + 1;
                        }
                        else
                        {
                            if (indiceDeSemanas.Contains(j))
                            {
                                indiceNumeroSemana = Convert.ToInt32(indiceDeSemanas[j]);
                            }
                        }

                        try
                        {
                            PresupuestoProduccionDetalleProdSemanal cantPorSemana = new PresupuestoProduccionDetalleProdSemanal();
                            numeroSemana = indiceNumeroSemana;
                            cantPorSemana.NumeroSemana = numeroSemana;
                            string valor = dataTable.Rows[i][j].ToString();                            
                            if (String.IsNullOrEmpty(valor))
                            {
                                cantPorSemana.Cantidad = 0;
                            }
                            else
                            {
                                valor = valor.Replace(" ", string.Empty);
                                if (!String.IsNullOrEmpty(valor))
                                {
                                    cantPorSemana.Cantidad = Convert.ToInt32(valor);
                                }
                                else
                                {
                                    cantPorSemana.Cantidad = 0;
                                }
                            }

                            presupuestoProduccionDetalleProd.CantidadesPorSemana.Add(cantPorSemana);
                        }
                        catch (Exception ex)
                        {
                            parseErrors.Add(string.Format("Excepción en fila {1} columna {2}: {0}", ex.Message, i, j));
                            break;
                        }
                    }

                    presupuestoProduccionDetalleProdList.Add(presupuestoProduccionDetalleProd);
                }
            }

            return presupuestoProduccionDetalleProdList;
        }

        public static List<PresupuestoProduccion> GetPresupuestosDeProduccionFromExcelObj(List<PresupuestoProduccionExcel> excelLines)
        {
            List<PresupuestoProduccion> presupuestosList = new List<PresupuestoProduccion>();

            List<int> proveedorIds = excelLines.Select(e => e.ProveedorId).Distinct().ToList();

            foreach (int proveedorId in proveedorIds)
            {
                List<PresupuestoProduccionExcel> excelLinesForProveedor = excelLines.Where(e => e.ProveedorId == proveedorId).ToList();
                if (excelLinesForProveedor.Count > 0)
                {
                    PresupuestoProduccionExcel firstLine = excelLinesForProveedor.First();
                    // Cargo el presupuesto
                    PresupuestoProduccion presupuestoProduccion = new PresupuestoProduccion();
                    presupuestoProduccion.ProveedorIdExterno = proveedorId;
                    presupuestoProduccion.TemporadaCodigoExterno = firstLine.TemporadaCodigoExterno;
                    presupuestoProduccion.DestinoCodigoExterno = firstLine.DestinoCodigoExterno;

                    presupuestosList.Add(presupuestoProduccion);

                    // Cargo el producto para el presupuesto
                    foreach (PresupuestoProduccionExcel excelLineObj in excelLinesForProveedor)
                    {
                        PresupuestoProduccionDetalleProd presupuestoProduccionDetalleProd = new PresupuestoProduccionDetalleProd();
                        presupuestoProduccionDetalleProd.ProductoIdExterno = excelLineObj.ProductoId;
                        presupuestoProduccionDetalleProd.ColorId = excelLineObj.ColorId;
                        presupuestoProduccion.DetalleDeProductos.Add(presupuestoProduccionDetalleProd);

                        // Cargo las semanas para el producto dentro del presupuesto
                        foreach (PresupuestoProduccionDetalleProdSemanal cantSemana in excelLineObj.CantidadesPorSemana)
                        {
                            presupuestoProduccionDetalleProd.CantidadesPorSemana.Add(cantSemana);
                        }
                    }
                }
            }

            return presupuestosList;
        }

        public static List<PresupuestoProduccionExcel> GetPresupuestosDeProduccionExcelObjFromExcel(string filePath)
        {
            List<PresupuestoProduccionExcel> excelAObjetosList = new List<PresupuestoProduccionExcel>();

            DataTable dataTable = GetDataTableFromExcel(filePath);
            int temporadaIndex = 0;
            int destinoIndex = 1;
            int proveedorIndex = 2;
            int productoIndex = 3;
            int colorIndex = 4;

            const int cantidadColumnas = 5;

            if (dataTable.Columns.Count <= cantidadColumnas)
            {
                throw new Exception(string.Format("El excel debe contener mas de {0} columnas", cantidadColumnas));
            }

            string temporada;
            string destino;
            string proveedor;
            string productoId;
            string colorId;

            PresupuestoProduccionExcel excelObj;
            for (int i = 0; i < dataTable.Rows.Count; i++)
            {
                if (dataTable.Rows[i][temporadaIndex] != DBNull.Value)
                {
                    excelObj = new PresupuestoProduccionExcel();
                    excelObj.Linea = i + 1;
                    excelAObjetosList.Add(excelObj);

                    temporada = dataTable.Rows[i][temporadaIndex].ToString();
                    if (!String.IsNullOrEmpty(temporada))
                    {
                        excelObj.TemporadaCodigoExterno = temporada;
                    }
                    else
                    {
                        excelObj.Errores.Add(string.Format("Fila {0}: la temporada no se pudo interpretar", excelObj.Linea));
                    }

                    destino = dataTable.Rows[i][destinoIndex].ToString();
                    if (!String.IsNullOrEmpty(destino))
                    {
                        excelObj.DestinoCodigoExterno = destino;
                    }
                    else
                    {
                        excelObj.Errores.Add(string.Format("Fila {0}: el destino no se pudo interpretar", excelObj.Linea));
                    }

                    proveedor = dataTable.Rows[i][proveedorIndex].ToString();
                    if (!String.IsNullOrEmpty(proveedor))
                    {
                        int proveedorInt;
                        if (Int32.TryParse(proveedor, out proveedorInt))
                        {
                            excelObj.ProveedorId = proveedorInt;
                        }
                        else
                        {
                            excelObj.Errores.Add(string.Format("Fila {0}: El proveedor no se pudo interpretar", excelObj.Linea));
                        }
                    }

                    productoId = dataTable.Rows[i][productoIndex].ToString();
                    if (!String.IsNullOrEmpty(productoId))
                    {
                        excelObj.ProductoId = productoId;
                    }
                    else
                    {
                        excelObj.Errores.Add(string.Format("Fila: {0}, columna: {1}, el valor del producto '{2}' no se pudo parsear", i, productoIndex, productoId));
                    }

                    colorId = dataTable.Rows[i][colorIndex].ToString();
                    if (!String.IsNullOrEmpty(colorId))
                    {
                        excelObj.ColorId = colorId;
                    }
                    else
                    {
                        excelObj.Errores.Add(string.Format("Fila: {0}, columna: {1}, el valor del color '{2}' no se pudo parsear", i, colorIndex, colorId));
                    }

                    int numeroSemana = 0;
                    List<PresupuestoProduccionDetalleProdSemanal> cantidadesPorSemana = new List<PresupuestoProduccionDetalleProdSemanal>();
                    for (int j = cantidadColumnas; j < dataTable.Columns.Count; j++)
                    {
                        int indiceNumeroSemana = j - cantidadColumnas + 1; ;

                        try
                        {
                            PresupuestoProduccionDetalleProdSemanal cantPorSemana = new PresupuestoProduccionDetalleProdSemanal();
                            numeroSemana = indiceNumeroSemana;
                            cantPorSemana.NumeroSemana = numeroSemana;
                            string valor = dataTable.Rows[i][j].ToString();
                            if (String.IsNullOrEmpty(valor))
                            {
                                cantPorSemana.Cantidad = 0;
                            }
                            else
                            {
                                cantPorSemana.Cantidad = Convert.ToInt32(valor);
                            }

                            excelObj.CantidadesPorSemana.Add(cantPorSemana);
                        }
                        catch (Exception ex)
                        {
                            excelObj.Errores.Add(string.Format("Excepción en fila {1} columna {2}: {0}", ex.Message, i, j));
                            break;
                        }
                    }
                }
            }

            return excelAObjetosList;
        }

        public static List<Producto> GetProductosFromExcel(string filePath, List<string> parseErrors)
        {
            List<Producto> productoList = new List<Producto>();

            DataTable dataTable = GetDataTableFromExcel(filePath);

            if (dataTable != null)
            {
                int productoExternoIndex = 0;
                int colorExternoIndex = 1;
                int nombreProductoIndex = 2;
                int nombreColorExternoIndex = 3;
                int temporadaIndex = 4;
                int marcaIndex = 5;
                int marcaDescIndex = 6;
                int origenIndex = 7;
                int origenDescIndex = 8;
                int lineaIndex = 9;
                int lineaDescIndex = 10;
                int familiaIndex = 11;
                int familiaDescIndex = 12;
                int subFamiliaIndex = 13;
                int subFamiliaDescIndex = 14;
                int productoExternoSegundaIndex = 15;

                int columns = 16;
                if (dataTable.Columns.Count != columns)
                {
                    parseErrors.Add(string.Format("El excel debe contener {0} columnas y contiene {1}", columns, dataTable.Columns.Count));
                }
                else
                {
                    for (int i = 0; i < dataTable.Rows.Count; i++)
                    {
                        Producto producto = new Producto();

                        try
                        {
                            if (dataTable.Rows[i][productoExternoIndex] != DBNull.Value)
                            {
                                producto.ProductoIdExterno = dataTable.Rows[i][productoExternoIndex].ToString();
                                producto.ColorIdExterno = dataTable.Rows[i][colorExternoIndex].ToString();
                                producto.ProductoNombre = dataTable.Rows[i][nombreProductoIndex].ToString();
                                producto.ColorNombreExterno = dataTable.Rows[i][nombreColorExternoIndex].ToString();
                                producto.TemporadaCodigoExterno = dataTable.Rows[i][temporadaIndex].ToString();                                
                                producto.MarcaIdExterno = dataTable.Rows[i][marcaIndex].ToString();
                                producto.MarcaNombreExterno = dataTable.Rows[i][marcaDescIndex].ToString();
                                producto.OrigenIdExterno = dataTable.Rows[i][origenIndex].ToString();
                                producto.OrigenNombreExterno = dataTable.Rows[i][origenDescIndex].ToString();
                                producto.LineaIdExterno = dataTable.Rows[i][lineaIndex].ToString();
                                producto.LineaNombreExterno = dataTable.Rows[i][lineaDescIndex].ToString();
                                producto.FamiliaIdExterno = dataTable.Rows[i][familiaIndex].ToString();
                                producto.FamiliaNombreExterno = dataTable.Rows[i][familiaDescIndex].ToString();
                                producto.SubFamiliaIdExterno = dataTable.Rows[i][subFamiliaIndex].ToString();
                                producto.SubFamiliaNombreExterno = dataTable.Rows[i][subFamiliaDescIndex].ToString();
                                producto.ProductoIdExternoSegunda = dataTable.Rows[i][productoExternoSegundaIndex].ToString();
                                productoList.Add(producto);
                            }
                        }
                        catch (Exception ex)
                        {
                            parseErrors.Add(string.Format("Linea {1}: Error={0}", ex.Message, i + 1));
                        }
                    }
                }
            }

            return productoList;
        }

        internal static List<IngresoDeProducto> GetIngresoDeProductosFromExcel(string filePath, List<string> parseErrors)
        {
            List<IngresoDeProducto> ingresoProductoList = new List<IngresoDeProducto>();

            DataTable dataTable = GetDataTableFromExcel(filePath);
            int destinoIndex = 0;
            int proveedorIndex = 1;
            int productoIndex = 2;
            int colorIndex = 3;
            int cantidadIndex = 4;
            int fechaIndex = 5;
            int temporadaIndex = 6;
            int remitoLetraIndex = 7;
            int remitoSucursalIndex = 8;
            int remitoNumeroIndex = 9;

            const int cantidadColumnas = 10;
            if (dataTable.Columns.Count != cantidadColumnas)
            {
                throw new Exception(string.Format("El excel debe contener {0} columnas", cantidadColumnas));
            }

            string value = string.Empty;
            for (int i = 0; i < cantidadColumnas; i++)
            {
                value = dataTable.Columns[i].ColumnName;
                if (value.ToLower() == "destino")
                {
                    destinoIndex = i;
                }
                else if (value.ToLower() == "proveedor")
                {
                    proveedorIndex = i;
                }
                else if (value.ToLower() == "producto")
                {
                    productoIndex = i;
                }
                else if (value.ToLower() == "color")
                {
                    colorIndex = i;
                }
                else if (value.ToLower() == "cantidad")
                {
                    cantidadIndex = i;
                }
                else if (value.ToLower() == "fecha")
                {
                    fechaIndex = i;
                }
                else if (value.ToLower() == "remitoletra")
                {
                    remitoLetraIndex = i;
                }
                else if (value.ToLower() == "remitosucursal")
                {
                    remitoSucursalIndex = i;
                }
                else if (value.ToLower() == "remitonumero")
                {
                    remitoNumeroIndex = i;
                }
            }

            string destino;
            int proveedor;
            string producto;
            string color;
            int cantidad;
            string temporada;
            string remitoLetra;
            int remitoSucursal;
            string remitoNumero;
            for (int i = 0; i < dataTable.Rows.Count; i++)
            {
                IngresoDeProducto ingreso = new IngresoDeProducto();

                destino = dataTable.Rows[i][destinoIndex].ToString();
                if (!String.IsNullOrEmpty(destino))
                {
                    ingreso.DestinoCodigoExterno = destino;
                }
                else
                {
                    parseErrors.Add(string.Format("Fila {0}, columna {1}: El destino {2} no se pudo interpretar", i + 1, destinoIndex, destino));
                }

                if (Int32.TryParse(dataTable.Rows[i][proveedorIndex].ToString(), out proveedor))
                {
                    ingreso.ProveedorIdExterno = proveedor;
                }
                else
                {
                    parseErrors.Add(string.Format("Fila {0}, columna {1}: El proveedor {2} no se pudo interpretar", i + 1, proveedorIndex, proveedor));
                }

                producto = dataTable.Rows[i][productoIndex].ToString();
                if (!String.IsNullOrEmpty(producto) && producto.Length == 8)
                {
                    ingreso.ProductoIdExterno = producto;
                }
                else
                {
                    parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar. Controle que sea un valor de 8 letras", i, productoIndex, producto));
                }

                color = dataTable.Rows[i][colorIndex].ToString();
                if (!String.IsNullOrEmpty(color) && color.Length == 3)
                {
                    ingreso.ColorIdExterno = color;
                }
                else
                {
                    parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar. Controle que sea un valor de 3 letras", i, colorIndex, color));
                }

                if (Int32.TryParse(dataTable.Rows[i][cantidadIndex].ToString(), out cantidad))
                {
                    ingreso.Cantidad = cantidad;
                }
                else
                {
                    parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar. Controle que sea un número entero", i, cantidadIndex, cantidad));
                }

                try
                {
                    DateTime fecha = (DateTime)dataTable.Rows[i][fechaIndex];
                    ingreso.FechaEntrega = fecha;
                }
                catch
                {
                    parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar. Controle que sea una fecha válida", i, fechaIndex, dataTable.Rows[i][fechaIndex]));
                }

                temporada = dataTable.Rows[i][temporadaIndex].ToString();
                if (!String.IsNullOrEmpty(temporada))
                {
                    ingreso.TemporadaCodigoExterno = temporada;
                }
                else
                {
                    parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar. ", i, temporadaIndex, temporada));
                }

                remitoLetra = dataTable.Rows[i][remitoLetraIndex].ToString();
                if (!String.IsNullOrEmpty(remitoLetra))
                {
                    ingreso.RemitoLetra = remitoLetra;
                }
                else
                {
                    parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar.", i, remitoLetraIndex, remitoLetra));
                }

                if (Int32.TryParse(dataTable.Rows[i][remitoSucursalIndex].ToString(), out remitoSucursal))
                {
                    ingreso.RemitoSucursal = remitoSucursal;
                }
                else
                {
                    parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar. Controle que sea un número entero", i, remitoSucursalIndex, remitoSucursal));
                }

                remitoNumero = dataTable.Rows[i][remitoNumeroIndex].ToString();
                if (!String.IsNullOrEmpty(remitoNumero))
                {
                    ingreso.RemitoNumero = remitoNumero;
                }
                else
                {
                    parseErrors.Add(string.Format("Fila {0}, columna {1}: El valor {2} no se pudo interpretar.", i, remitoNumeroIndex, remitoNumero));
                }


                ingresoProductoList.Add(ingreso);

            }

            return ingresoProductoList;
        }

        private static DataTable GetDataTableFromExcel(string filePath)
        {
            return ExcelHelperBase.GetDataTableFromExcel(filePath);
        }
    }

    public class PresupuestoProduccionExcel
    {
        public PresupuestoProduccionExcel()
        {
            Errores = new List<string>();
            CantidadesPorSemana = new List<PresupuestoProduccionDetalleProdSemanal>();
        }

        public int Linea { get; set; }

        public string TemporadaCodigoExterno { get; set; }

        public string DestinoCodigoExterno { get; set; }

        public int ProveedorId { get; set; }

        public string ProductoId { get; set; }

        public string ColorId { get; set; }

        public List<PresupuestoProduccionDetalleProdSemanal> CantidadesPorSemana { get; set; }

        public List<string> Errores { get; set; }

        public bool HasError
        {
            get
            {
                return Errores.Count > 0;
            }
        }
    }
}